home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / fenv.a < prev    next >
Encoding:
Text File  |  1998-02-12  |  11.8 KB  |  325 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        fenv.a
  3. ;
  4. ;    Contains:    Floating-Point environment for PowerPC and 68K
  5. ;
  6. ;    Version:    Technology:    MathLib v2
  7. ;                Release:    Universal Interfaces 3.1
  8. ;
  9. ;    Copyright:    © 1987-1998 by Apple Computer, Inc., all rights reserved.
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__FENV__') = 'UNDEFINED' THEN
  19. __FENV__ SET 1
  20.  
  21.     IF &TYPE('__CONDITIONALMACROS__') = 'UNDEFINED' THEN
  22.     include 'ConditionalMacros.a'
  23.     ENDIF
  24.  
  25.     IF TARGET_OS_MAC THEN
  26. ; 
  27. ;    A collection of functions designed to provide access to the floating
  28. ;    point environment for numerical programming. It is modeled after
  29. ;    the floating-point requirements in C9X.
  30. ;    
  31. ;    The file <fenv.h> declares many functions in support of numerical
  32. ;    programming.  It provides a set of environmental controls similar to
  33. ;    the ones found in <SANE.h>.  Programs that test flags or run under
  34. ;    non-default modes must do so under the effect of an enabling
  35. ;    "fenv_access" pragma.
  36. ;
  37.  
  38.  
  39. ; ********************************************************************************
  40. ;*                                                                                *
  41. ;*    fenv_t         is a type for representing the entire floating-point        *
  42. ;*                     environment in a single object.                              *
  43. ;*                                                                                *
  44. ;*     fexcept_t        is a type for representing the floating-point                *
  45. ;*                     exception flag state collectively.                           *
  46. ;*                                                                                *
  47. ;*******************************************************************************
  48.  
  49.     IF TARGET_CPU_PPC THEN
  50. ; typedef long                             fenv_t
  51.  
  52. ; typedef long                             fexcept_t
  53.  
  54. ;     Definitions of floating-point exception macros                          
  55.  
  56. FE_INEXACT                        EQU        $02000000
  57. FE_DIVBYZERO                    EQU        $04000000
  58. FE_UNDERFLOW                    EQU        $08000000
  59. FE_OVERFLOW                        EQU        $10000000
  60. FE_INVALID                        EQU        $20000000
  61.  
  62. ;     Definitions of rounding direction macros                                
  63.  
  64. FE_TONEAREST                    EQU        $00000000
  65. FE_TOWARDZERO                    EQU        $00000001
  66. FE_UPWARD                        EQU        $00000002
  67. FE_DOWNWARD                        EQU        $00000003
  68.     ENDIF    ; TARGET_CPU_PPC
  69.     IF TARGET_CPU_68K THEN
  70.     IF TARGET_RT_MAC_68881 THEN
  71. ; typedef long                             fexcept_t
  72.  
  73. fenv_t                    RECORD 0
  74. FPCR                     ds.l    1                ; offset: $0 (0)
  75. FPSR                     ds.l    1                ; offset: $4 (4)
  76. sizeof                     EQU *                    ; size:   $8 (8)
  77.                         ENDR
  78.  
  79. FE_INEXACT                        EQU        $00000008            ; ((long)(8))   
  80. FE_DIVBYZERO                    EQU        $00000010            ; ((long)(16))  
  81. FE_UNDERFLOW                    EQU        $00000020            ; ((long)(32))  
  82. FE_OVERFLOW                        EQU        $00000040            ; ((long)(64))  
  83. FE_INVALID                        EQU        $00000080            ; ((long)(128)) 
  84.     ELSE
  85. ; typedef short                         fexcept_t
  86.  
  87. ; typedef short                         fenv_t
  88.  
  89.  
  90. FE_INVALID                        EQU        $0001                ; ((short)(1))  
  91. FE_UNDERFLOW                    EQU        $0002                ; ((short)(2))  
  92. FE_OVERFLOW                        EQU        $0004                ; ((short)(4))  
  93. FE_DIVBYZERO                    EQU        $0008                ; ((short)(8))  
  94. FE_INEXACT                        EQU        $0010                ; ((short)(16)) 
  95.     ENDIF    ; TARGET_RT_MAC_68881
  96.  
  97. FE_TONEAREST                    EQU        $0000                ; ((short)(0))  
  98. FE_UPWARD                        EQU        $0001                ; ((short)(1))  
  99. FE_DOWNWARD                        EQU        $0002                ; ((short)(2))  
  100. FE_TOWARDZERO                    EQU        $0003                ; ((short)(3))  
  101. ;     Definitions of rounding precision macros  (68K only)                    
  102.  
  103. FE_LDBLPREC                        EQU        $0000                ; ((short)(0))  
  104. FE_DBLPREC                        EQU        $0001                ; ((short)(1))  
  105. FE_FLTPREC                        EQU        $0002                ; ((short)(2))  
  106.     ENDIF    ; TARGET_CPU_68K
  107. ;     The bitwise OR of all exception macros                                  
  108. ; *******************************************************************************
  109. ;*     The following functions provide access to the exception flags.  The      *
  110. ;*     "int" input argument can be constructed by bitwise ORs of the exception  *
  111. ;*     macros: for example: FE_OVERFLOW | FE_INEXACT.                           *
  112. ;******************************************************************************
  113.  
  114. ; *******************************************************************************
  115. ;*     The function "feclearexcept" clears the supported exceptions represented *
  116. ;*     by its argument.                                                         *
  117. ;******************************************************************************
  118.  
  119. ;
  120. ; extern void feclearexcept(int excepts)
  121. ;
  122.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  123.         IMPORT_CFM_FUNCTION feclearexcept
  124.     ENDIF
  125.  
  126.  
  127.  
  128. ; *******************************************************************************
  129. ;*    The function "fegetexcept" stores a representation of the exception       *
  130. ;*     flags indicated by the argument "excepts" through the pointer argument   *
  131. ;*     "flagp".                                                                 *
  132. ;******************************************************************************
  133.  
  134. ;
  135. ; extern void fegetexcept(fexcept_t *flagp, int excepts)
  136. ;
  137.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  138.         IMPORT_CFM_FUNCTION fegetexcept
  139.     ENDIF
  140.  
  141.  
  142.  
  143. ; *******************************************************************************
  144. ;*     The function "feraiseexcept" raises the supported exceptions             *
  145. ;*     represented by its argument.                                             *
  146. ;******************************************************************************
  147.  
  148. ;
  149. ; extern void feraiseexcept(int excepts)
  150. ;
  151.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  152.         IMPORT_CFM_FUNCTION feraiseexcept
  153.     ENDIF
  154.  
  155.  
  156.  
  157. ; *******************************************************************************
  158. ;*     The function "fesetexcept" sets or clears the exception flags indicated  *
  159. ;*     by the int argument "excepts" according to the representation in the     *
  160. ;*     object pointed to by the pointer argument "flagp".  The value of         *
  161. ;*     "*flagp" must have been set by a previous call to "fegetexcept".         *
  162. ;*     This function does not raise exceptions; it just sets the state of       *
  163. ;*     the flags.                                                               *
  164. ;******************************************************************************
  165.  
  166. ;
  167. ; extern void fesetexcept(const fexcept_t *flagp, int excepts)
  168. ;
  169.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  170.         IMPORT_CFM_FUNCTION fesetexcept
  171.     ENDIF
  172.  
  173.  
  174.  
  175. ; *******************************************************************************
  176. ;*     The function "fetestexcept" determines which of the specified subset of  *
  177. ;*     the exception flags are currently set.  The argument "excepts" specifies *
  178. ;*     the exception flags to be queried as a bitwise OR of the exception       *
  179. ;*     macros.  This function returns the bitwise OR of the exception macros    *
  180. ;*     corresponding to the currently set exceptions included in "excepts".     *
  181. ;******************************************************************************
  182.  
  183. ;
  184. ; extern int fetestexcept(int excepts)
  185. ;
  186.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  187.         IMPORT_CFM_FUNCTION fetestexcept
  188.     ENDIF
  189.  
  190.  
  191.  
  192. ; *******************************************************************************
  193. ;*     The following functions provide control of rounding direction modes.     *
  194. ;******************************************************************************
  195.  
  196. ; *******************************************************************************
  197. ;*     The function "fegetround" returns the value of the rounding direction    *
  198. ;*     macro which represents the current rounding direction.                   *
  199. ;******************************************************************************
  200.  
  201. ;
  202. ; extern int fegetround(void )
  203. ;
  204.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  205.         IMPORT_CFM_FUNCTION fegetround
  206.     ENDIF
  207.  
  208.  
  209.  
  210. ; *******************************************************************************
  211. ;*     The function "fesetround" establishes the rounding direction represented *
  212. ;*     by its argument.  It returns nonzero if and only if the argument matches *
  213. ;*     a rounding direction macro.  If not, the rounding direction is not       *
  214. ;*     changed.                                                                 *
  215. ;******************************************************************************
  216.  
  217. ;
  218. ; extern int fesetround(int round)
  219. ;
  220.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  221.         IMPORT_CFM_FUNCTION fesetround
  222.     ENDIF
  223.  
  224.  
  225.  
  226. ; *******************************************************************************
  227. ;*    The following functions manage the floating-point environment, exception  *
  228. ;*    flags and dynamic modes, as one entity.                                   *
  229. ;******************************************************************************
  230.  
  231. ; *******************************************************************************
  232. ;*     The function "fegetenv" stores the current floating-point environment    *
  233. ;*     in the object pointed to by its pointer argument "envp".                 *
  234. ;******************************************************************************
  235.  
  236. ;
  237. ; extern void fegetenv(fenv_t *envp)
  238. ;
  239.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  240.         IMPORT_CFM_FUNCTION fegetenv
  241.     ENDIF
  242.  
  243.  
  244.  
  245. ; *******************************************************************************
  246. ;*     The function "feholdexcept" saves the current environment in the object  *
  247. ;*     pointed to by its pointer argument "envp", clears the exception flags,   *
  248. ;*     and clears floating-point exception enables.  This function supersedes   *
  249. ;*     the SANE function "procentry", but it does not change the current        *
  250. ;*     rounding direction mode.                                                 *
  251. ;******************************************************************************
  252.  
  253. ;
  254. ; extern int feholdexcept(fenv_t *envp)
  255. ;
  256.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  257.         IMPORT_CFM_FUNCTION feholdexcept
  258.     ENDIF
  259.  
  260.  
  261.  
  262. ; *******************************************************************************
  263. ;*     The function "fesetenv" installs the floating-point environment          *
  264. ;*     environment represented by the object pointed to by its argument         *
  265. ;*     "envp".  The value of "*envp" must be set by a call to "fegetenv" or     *
  266. ;*     "feholdexcept", by an implementation-defined macro of type "fenv_t",     *
  267. ;*     or by the use of the pointer macro FE_DFL_ENV as the argument.           *
  268. ;******************************************************************************
  269.  
  270. ;
  271. ; extern void fesetenv(const fenv_t *envp)
  272. ;
  273.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  274.         IMPORT_CFM_FUNCTION fesetenv
  275.     ENDIF
  276.  
  277.  
  278.  
  279. ; *******************************************************************************
  280. ;*     The function "feupdateenv" saves the current exceptions into its         *
  281. ;*     automatic storage, installs the environment represented through its      *
  282. ;*     pointer argument "envp", and then re-raises the saved exceptions.        *
  283. ;*     This function, which supersedes the SANE function "procexit", can be     *
  284. ;*     used in conjunction with "feholdexcept" to write routines which hide     *
  285. ;*     spurious exceptions from their callers.                                  *
  286. ;******************************************************************************
  287.  
  288. ;
  289. ; extern void feupdateenv(const fenv_t *envp)
  290. ;
  291.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  292.         IMPORT_CFM_FUNCTION feupdateenv
  293.     ENDIF
  294.  
  295.  
  296.  
  297.     IF TARGET_CPU_68K THEN
  298. ; *******************************************************************************
  299. ;*     The following functions provide control of rounding precision.           *
  300. ;*     Because the PowerPC does not provide this capability, these functions    *  
  301. ;*     are available only for the 68K Macintosh.  Rounding precision values     *
  302. ;*     are defined by the rounding precision macros.  These functions are       *
  303. ;*     equivalent to the SANE functions getprecision and setprecision.          *
  304. ;******************************************************************************
  305.  
  306. ;
  307. ; extern int fegetprec(void )
  308. ;
  309.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  310.         IMPORT_CFM_FUNCTION fegetprec
  311.     ENDIF
  312.  
  313. ;
  314. ; extern int fesetprec(int precision)
  315. ;
  316.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  317.         IMPORT_CFM_FUNCTION fesetprec
  318.     ENDIF
  319.  
  320.     ENDIF    ; TARGET_CPU_68K
  321.     ENDIF    ; TARGET_OS_MAC
  322.  
  323.     ENDIF ; __FENV__ 
  324.  
  325.